import static org.junit.Assert.assertEquals;

import org.junit.Test;


/**
 * 
 */


/**
 * @author Trefzger
 *
 */
public class OperandTypeTestV2 {
	
	/**
	 * Module Name:
	 * Description:
	 * Calling Sequence
	 * 		Input Parameters
	 * 		Output Parameters
	 * Error Conditions Tested:
	 * Error Messages Generated:
	 * Original Author:
	 * Procedure Creation Date:
	 * Modification Log:
	 * 	 Who/When/Why
	 * Coding Standards Met: "Signed Code Leader(Jaron)"
	 * Testing Standards Met: "Signed Test Leader(Jamie)"
	 */

	@Test
	public void validateNoneTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test null
		String testOperand = null;
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NONE, false);
		assertEquals("isValid should be true.", true, isValid);
	} 
	@Test
	public void validateNoneTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test an invalid string
		String testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NONE, false);
		assertEquals("isValid should be false.", false, isValid);
	} 
	@Test
	public void validateNoneTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test an empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NONE, false);
		assertEquals("isValid should be false.", false, isValid);
	} 
	@Test
	public void validateNoneTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a string of whitespace
		String testOperand = "   ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NONE, false);
		assertEquals("isValid should be false.", false, isValid);
	} 
	
	
	
	
	
	@Test
	public void validateType1Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid lower bound
		String testOperand = "0";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType1Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid string
		String 	testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be false.", false, isValid);
	}	@Test
	public void validateType1Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be false.", false, isValid);
	}	@Test
	public void validateType1Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be false.", false, isValid);
	}	@Test
	public void validateType1Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid upper bound
		String testOperand = "4095";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be true.", true, isValid);
	}	@Test
	public void validateType1Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid value outside of upper bound
		String testOperand = "4096";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be false.", false, isValid);
	}	@Test
	public void validateType1Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid value in the middle-ish
		String testOperand = "2000";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	
	@Test
	public void validateType2Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid lower bound
		String testOperand = "0";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType2Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test long string of whitespace
		String testOperand = " 	 	 	";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid upper bound
		String testOperand = "4095";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType2Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test limit out of upper bound
		String testOperand = "4096";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid middle-ish value
		String testOperand = "2000";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType2Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid label
		String testOperand = "TEST-label";
		
		// THIS IS FALSE! "-" is not a valid label character... only letters, number, "_", and "." are allowed.
		SymbolTable.startSymbolTable();
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test value way out of upper bound
		String testOperand = "0203040506";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test9() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test string too short to be a valid label
		String testOperand = "a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test10() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string too long to be a valid label
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test11() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test string to long to be valid, with numbers
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType2Test12() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string 64 characters long(allowable) with numbers in it
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		
		// testOperand must be a previously equated symbol for this to be valid!
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand, "EQU");
		SymbolTable.editEQUValue(testOperand, "10");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE2, false);
		assertEquals("isValid should be true.", true, isValid);
	}

	
	
	
	@Test
	public void validateType3Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test value lower than lower bound
		String testOperand = "-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid label
		String testOperand = "END";
		
		// END must be in the symbol table as an equated symbol for this to be valid...
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand,"EQU");
		SymbolTable.editEQUValue(testOperand, "2");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType3Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test lower bound
		String testOperand = "0";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType3Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test intermediate value
		String testOperand = "1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType3Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test upper bound
		String testOperand = "2";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType3Test8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid label
		String testOperand = "TEST-label";
		
		// this is not a valid label name... - is not a valid character...
		// also the operand would have to be in the symbol table as an equated value for this to be valid...
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateType3Test9() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test large number
		String testOperand = "01020304050";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test10() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test larger number. this shouldnt throw an error, but we should.
		String testOperand = "010203040506";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test11() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test value out of upper bound
		String testOperand = "3";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test12() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test13() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test label of invalid length
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test14() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label of invalid length with numbers
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType3Test15() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label with 64 characters
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		
		// testOperand must be in the symbol table as an EQU for this to be true...
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand,"EQU");
		SymbolTable.editEQUValue(testOperand, "2");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	@Test
	public void validateType4Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test value lower than lower bound
		String testOperand = "-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid label
		String testOperand = "END";
		
		// testOperand must be in the symbol table as an EQU for this to be true...
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand,"EQU");
		SymbolTable.editEQUValue(testOperand, "23");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType4Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test lower bound
		String testOperand = "0";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType4Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test intermediate value
		String testOperand = "11";
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType4Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test upper bound
		String testOperand = "23";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType4Test8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid label
		String testOperand = "TEST_label";
		
		// testOperand must be in the symbol table as an EQU for this to be true...
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand,"EQU");
		SymbolTable.editEQUValue(testOperand, "23");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateType4Test9() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test large number
		String testOperand = "01020304050";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test10() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test larger number. this shouldnt throw an error, but we should.
		String testOperand = "010203040506";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test11() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test value out of upper bound
		String testOperand = "24";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test12() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test13() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test label of invalid length
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test14() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label of invalid length with numbers
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateType4Test15() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label with 64 characters
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		
		// testOperand must be in the symbol table as an EQU for this to be true...
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol(testOperand);
		SymbolTable.editUsage(testOperand,"EQU");
		SymbolTable.editEQUValue(testOperand, "0");
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.TYPE4, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	
	
	@Test
	public void validateOnOffTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid 'on' with mixed case
		String testOperand = "On";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateOnOffTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid 'off' with mixed case
		String testOperand = "oFF";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateOnOffTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid operand
		String testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateOnOffTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test empty string
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateOnOffTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateOnOffTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test the stupid large number that throws a java error on the other tests.
		String testOperand = "010203040506";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ONOFF, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	@Test
	public void validateNumTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test lower bound
		String testOperand = "-8388608";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateNumTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test upper bound
		String testOperand = "8388607";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateNumTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid string
		String testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateNumTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//empty string fails us yet again
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateNumTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateNumTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test out of upper bound
		String testOperand = "16777216";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateNumTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test out of lower bound
		String testOperand = "-16777217";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.NUM, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	@Test
	public void validateBinTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test binary string of valid length
		String testOperand = "11111111111111111111111";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateBinTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test binary string with leading zeroes, of proper length?
		String testOperand = "0000000000000000000000001";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateBinTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateBinTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//empty string 
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateBinTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of whitespace
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateBinTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid numbers
		String testOperand = "01234567";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
		
	}
	@Test
	public void validateBinTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test more invalid numbers? not sure why i made this test
		String testOperand = "11001455823";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateBinTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of valid numbers, of invalid length.
		String testOperand = "1111111111111111111111111";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.BIN, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	@Test
	public void validateStarTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test the ONLY valid operand
		String testOperand = "*";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateStarTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//invalid label
		String testOperand = "END";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateStarTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//empty string fails... again...
		String testOperand = "";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateStarTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of white space
		String testOperand = " ";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateStarTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test invalid numbers
		String testOperand = "01234567";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateStarTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//more invalid numbers for some reason
		String testOperand = "11001455823";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.STAR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	@Test
	public void validateHexTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid hex chars
		String	testOperand = "abcdef";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateHexTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid hex chars beginning with '0x'
		String	testOperand = "0xabcdef";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateHexTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid hex numbers
		String	testOperand = "012345";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateHexTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test the other valid hex numbers
		String	testOperand = "678910";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateHexTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid hex chars
		String	testOperand = "adg910";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateHexTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test hex string of invalid length
		String	testOperand = "1234567";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateHexTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid string
		String	testOperand = "END";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateHexTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test empty string case
		String	 testOperand = "";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateHexTest9() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test string of whitespace
		String	testOperand = " ";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateHexTest10() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test string of numbers way too long.
		String	testOperand = "11001455823";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.HEX, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	
	@Test
	public void validateCharTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test valid input
		String  testOperand = "'abc'";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//valid input with whitespace
		String   testOperand = "'a a'";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test more valid input with whitespace
		String  testOperand = "'  b'";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//2 character input with whitespace
		String   testOperand = "'m '";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//too many chars
		String  testOperand = "'abcd'";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateCharTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//valid number characters
		String   testOperand = "'321'";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test whitespace only
		String  testOperand = "' '";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateCharTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// empty sting strikes again!
		String  testOperand = "''";
        isValid = testop.validateOperandType(testOperand, OperandType.operandType.CHR, false);
        assertEquals("isValid should be false.", false, isValid); 
	}
	
	
	
	
	
	
	
	@Test
	public void validateExpression1Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*+1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExpression1Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExpression1Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression
		String testOperand = "**1";
		
		// THIS IS A VALID EXPRESSION1!
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be false.", true, isValid);
	}
	@Test
	public void validateExpression1Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression
		String testOperand = "*/1";
		
		// THIS IS A VALID EXPRESSION1!
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be false.", true, isValid);
	}
	@Test
	public void validateExpression1Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "=2+1";
		
		// THIS IS NOT VALID! You can not have an equals sign in an EQU???
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression1Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "=2+1+20+5-2";
		
		// THIS IS NOT VALID! You can not have an equals sign in an EQU???
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression1Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//is that a valid star expression?
		String testOperand = "*-1+5-2";
		
		// this is not a valid star expression...
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION1, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	@Test
	public void validateExpression2Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*+1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression2Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression2Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression
		String testOperand = "**1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression2Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression
		String testOperand = "*/1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression2Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "res=AA/BB+20*4-6";
		SymbolTable.startSymbolTable();
		SymbolTable.addSymbol("res");
		SymbolTable.editUsage("res","EXTERNAL");
		SymbolTable.addSymbol("AA");
		SymbolTable.editUsage("AA","EQU");
		SymbolTable.editEQUValue("AA", "10");
		SymbolTable.addSymbol("BB");
		SymbolTable.editUsage("BB","EQU");
		SymbolTable.editEQUValue("BB", "2");
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExpression2Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "=2+1+20+5-2";
		
		// there has to be something to the left of the equals sign...
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression2Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//is that a valid star expression?
		String testOperand = "*-1+5-2";
		
		//this is not valid...
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression2Test8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid expression
		String testOperand = "8-1+5-2";
		SymbolTable.startSymbolTable();
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	@Test
	public void validateExpression3Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*+1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExpression3Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid star expression
		String testOperand = "*-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExpression3Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression... it is invalid right?
		String testOperand = "**1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression3Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a invalid star expression... it is invalid right?
		String testOperand = "*/1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExpression3Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "=2+1";
		
		// this is not valid
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression3Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal expression
		String testOperand = "=2+1+20+5-2";
		
		//this is not valid
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateExpression3Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//is that a valid star expression?
		String testOperand = "*-1+5-2";
		
		//this is not valid
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXPRESSION3, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	@Test
	public void validateRefExpTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid ref-exp
		String testOperand = "*-mud";
		SymbolTable.startSymbolTable();
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRefExpTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//is that a valid star expression?
		String testOperand = "*-mud+dirt+sand";
		
		// this is not valid
		
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void validateRefExpTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//valid ref-exp
		String testOperand = "*+mud";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRefExpTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//should be invalid
		String testOperand = "**mud";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRefExpTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//should be invalid
		String testOperand = "*/mud";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRefExpTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//valid ref-exp
		String testOperand = "*-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRefExpTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a literal
		String testOperand = "*-=5";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRefExpTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a register
		String testOperand = "*-IR";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REFEXP, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	@Test
	public void validateRef1Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		
		String testOperand = "Valid-LABel";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef1Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef1Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test label of invalid length
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef1Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label of invalid length with numbers
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef1Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label with 64 characters
		String testOperand = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef1Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number in range
		String testOperand = "15";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef1Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number out of range
		String testOperand = "5015";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF1, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	@Test
	public void validateRef2Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		
		String testOperand = "#Valid-LABel";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef2Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "#a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef2Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test label of invalid length
		String testOperand = "#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef2Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label of invalid length with numbers
		String testOperand = "#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef2Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label with 64 characters
		String testOperand = "#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef2Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number in range
		String testOperand = "#15";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef2Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number out of range
		String testOperand = "#5015";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF2, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	
	
	@Test
	public void validateRef3Test1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		
		String testOperand = "%Valid-LABel";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef3Test2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test invalid label
		String testOperand = "%a";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef3Test3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test label of invalid length
		String testOperand = "%abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef3Test4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label of invalid length with numbers
		String testOperand = "%abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateRef3Test5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test label with 64 characters
		String testOperand = "%abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef3Test6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number in range
		String testOperand = "%15";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateRef3Test7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a number out of range
		String testOperand = "%5015";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.REF3, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	@Test
	public void validateLabelTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid labels
		String testOperand = "label,label2,label3,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateLabelTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid labels with spaces after commas
		String testOperand = "label, label2,   label3,    	label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be false.", true, isValid);
	}
	@Test
	public void validateLabelTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an invalid label
		String testOperand = "label,label2,label3,abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateLabelTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an invalid label(extra label)
		String testOperand = "label,label2,label3,label4,label5";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateLabelTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an empty label
		String testOperand = "label,label2,,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateLabelTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a whitespace label
		String testOperand = "label,label2, ,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.LABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	@Test
	public void validateExlabelTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid labels
		String testOperand = "label,label2,label3,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateExlabelTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test valid labels with spaces after commas
		String testOperand = "label, label2,   label3,    	label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be false.", true, isValid);
	}
	@Test
	public void validateExlabelTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an invalid label
		String testOperand = "label,label2,label3,abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExlabelTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an invalid label(extra label)
		String testOperand = "label,label2,label3,label4,label5";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExlabelTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test an empty label
		String testOperand = "label,label2,,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateExlabelTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// test a whitespace label
		String testOperand = "label,label2, ,label4";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.EXLABEL, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	
	
	@Test
	public void validateAddressTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test lower bound
		String testOperand = "0";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ADDR, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateAddressTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test intermediate value
		String testOperand = "2011";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ADDR, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateAddressTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test upper bound
		String testOperand = "4095";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ADDR, false);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void validateAddressTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test outside of upper bound
		String testOperand = "4096";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ADDR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void validateAddressTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test below lower bound
		String testOperand = "-1";
		isValid = testop.validateOperandType(testOperand, OperandType.operandType.ADDR, false);
		assertEquals("isValid should be false.", false, isValid);
	}
	
	
	
	
	
	
	
	
	
	@Test
	public void isValidLabelTypeTest1() {
		Boolean isValid = true;
		//test a number
		String testLabel = "-1";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest2() {
		Boolean isValid = true;
		//test a valid label
		String testLabel = "TEST-label";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLabelTypeTest3() {
		Boolean isValid = true;
		//test a label of invalid length
		String testLabel = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest4() {
		Boolean isValid = true;
		//test a label of invalid length with numbers and characters
		String testLabel = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678910111213141516";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest5() {
		Boolean isValid = true;
		//test a label at the maximum valid length of 64 chraracters
		String testLabel = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789064";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLabelTypeTest6() {
		Boolean isValid = true;
		//test a label shorter than the minimum 2 character length requirement.
		String testLabel = "a";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest7() {
		Boolean isValid = true;
		//test a label with whitespace(invalid)
		String testLabel = " a";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest8() {
		Boolean isValid = true;
		//test a label of whitespace (invalid)
		String testLabel = " ";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest9() {
		Boolean isValid = true;
		//test the empty string case
		String testLabel = "";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest10() {
		Boolean isValid = true;
		//test a literal instead of a label
		String testLabel = "=15";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest11() {
		Boolean isValid = true;
		//test label with invalid characters
		String testLabel = "h(o)wdy";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLabelTypeTest12() {
		Boolean isValid = true;
		//test label with valid characters
		String testLabel = "h._-lcs";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLabelTypeTest13() {
		Boolean isValid = true;
		//test a label of the minimum 2 character length requirement.
		String testLabel = "aa";
		isValid = OperandType.isValidLabelType(testLabel);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	
	
	
	@Test
	public void isValidLiteralTypeTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid literal
		String testLiteral = "=15";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLiteralTypeTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test lower bound
		String testLiteral = "=-8388608";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLiteralTypeTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a huge number
		String testLiteral = "=010203040506";
		
		//this is not true... it's pretty far out of range...
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void isValidLiteralTypeTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test upper bound
		String testLiteral = "=8388607";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLiteralTypeTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//can we have a negative literal?
		String testLiteral = "=-15";
		
		// yes negative literals are valid...
		
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be false.", true, isValid);
	}
	@Test
	public void isValidLiteralTypeTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//should this one be true?(no single quotes)
		String testLiteral = "=abc";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isValidLiteralTypeTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid character literal
		String testLiteral = "='abc'";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isValidLiteralTypeTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a valid character literal with whitespace
		String testLiteral = "=' b '";
		isValid = testop.isValidLiteralType(testLiteral);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	
	
	@Test
	public void isNumberBetweenTest1() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test if the lower and upper bounds are the same,
		//if the same value is considered between
		String testNumber = "0";
		isValid = testop.isNumberBetween(testNumber, 0, 0);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberBetweenTest2() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		// what happens when mins and maxes are mixed up?
		String testNumber = "4";
		isValid = testop.isNumberBetween(testNumber, 5, 3);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberBetweenTest3() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test an intermediate value
		String testNumber = "4";
		isValid = testop.isNumberBetween(testNumber, 3, 5);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberBetweenTest4() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a giant number
		String testNumber = "010203040506";
		
		// this number is beyond the bounds of java... it is not valid
		
		isValid = testop.isNumberBetween(testNumber, 0, 010203040507);
		assertEquals("isValid should be true.", false, isValid);
	}
	@Test
	public void isNumberBetweenTest5() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test if the max value counts as 'between'
		String testNumber = "1";
		isValid = testop.isNumberBetween(testNumber, 0, 1);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberBetweenTest6() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a value out of range (not inbetween)
		String testNumber = "7";
		isValid = testop.isNumberBetween(testNumber, 1, 5);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberBetweenTest7() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a negative
		String testNumber = "-4";
		isValid = testop.isNumberBetween(testNumber, -11, 5);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberBetweenTest8() {
		Boolean isValid = true;
		OperandType testop = new OperandType();
		//test a positive, with a negative lower bound
		String testNumber = "4";
		isValid = testop.isNumberBetween(testNumber, -11, 5);
		assertEquals("isValid should be true.", true, isValid);
	}
	
	
	
	
	
	
	
	@Test
	public void isNumberTest1() {
		Boolean isValid = true;
		//test a number
		String testNumber = "4";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberTest2() {
		Boolean isValid = true;
		//test with leading zeroes
		String testNumber = "03";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberTest3() {
		Boolean isValid = true;
		//test a huge number
		String testNumber = "010203040506070809";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberTest4() {
		Boolean isValid = true;
		//test a large number
		String testNumber = "5000";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be true.", true, isValid);
	}
	@Test
	public void isNumberTest5() {
		Boolean isValid = true;
		//test a non number string
		String testNumber = "bob";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest6() {
		Boolean isValid = true;
		//test the empty string case
		String testNumber = "";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest7() {
		Boolean isValid = true;
		//test a number with whitespace
		String testNumber = "  4";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest8() {
		Boolean isValid = true;
		//test whitespace
		String testNumber = "  ";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest9() {
		Boolean isValid = true;
		//test numbers with letters mixed in the middle
		String testNumber = "123abc567";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest10() {
		Boolean isValid = true;
		//test weird symbols w/ numbers
		String testNumber = "12:45";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
	@Test
	public void isNumberTest11() {
		Boolean isValid = true;
		//test numbers with whitespace between
		String testNumber = "12 3";
		isValid = OperandType.isNumber(testNumber);
		assertEquals("isValid should be false.", false, isValid);
	}
}